const express = require('express');
const cors = require('cors');
const morgan = require('morgan');
const { notFound, errorHandler } = require('./middlewares/error.middleware');
const {
  performanceMonitor,
  slowQueryMonitor,
  memoryLeakMonitor,
  rateLimiter,
  healthCheck
} = require('./middlewares/performance.middleware');
// 使用自定义的数据库连接
const db = require('../database/db');
require('dotenv').config();

// 验证必需的环境变量
if (!process.env.JWT_SECRET) {
  console.error('❌ 错误: JWT_SECRET 环境变量未设置');
  process.exit(1);
}

if (!process.env.MONGODB_URI) {
  console.error('❌ 错误: MONGODB_URI 环境变量未设置');
  process.exit(1);
}

// 导入路由
const productRoutes = require('./routes/product.routes');
const userRoutes = require('./routes/user.routes');
const cartRoutes = require('./routes/cart.routes');
const orderRoutes = require('./routes/order.routes');
const categoryRoutes = require('./routes/category.routes');
const shopRoutes = require('./routes/shop.routes');
const setupRoutes = require('./routes/setup.routes');
const bannerRoutes = require('./routes/banner.routes');
const uploadRoutes = require('./routes/upload.routes');

// 设置默认环境为生产环境
process.env.NODE_ENV = process.env.NODE_ENV || 'production';

// 初始化Express应用
const app = express();
const PORT = process.env.PORT || 5000;

// 详细的CORS配置
const allowedOrigins = process.env.ALLOWED_ORIGINS
  ? process.env.ALLOWED_ORIGINS.split(',')
  : [
    'http://localhost:3000',
    'http://localhost:5014', // 管理后台
    'http://localhost:8081', // React Native Metro
    'http://10.0.2.2:3002',  // Android模拟器
  ];

const corsOptions = {
  origin: function (origin, callback) {
    // 允许没有origin的请求（如移动应用）
    if (!origin) return callback(null, true);

    // 开发环境允许localhost的任何端口
    if (process.env.NODE_ENV === 'development' && origin.includes('localhost')) {
      return callback(null, true);
    }

    // 检查是否在允许列表中
    if (allowedOrigins.includes(origin)) {
      callback(null, true);
    } else {
      console.warn(`🚫 CORS阻止了来自 ${origin} 的请求`);
      callback(new Error('CORS策略不允许此源'), false);
    }
  },
  methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
  allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With', 'Accept', 'Origin', 'Cache-Control'],
  exposedHeaders: ['Content-Disposition'], // 用于文件下载
  credentials: true,
  optionsSuccessStatus: 200,
  maxAge: 86400 // 预检请求结果缓存24小时
};

// 性能监控中间件
app.use(performanceMonitor);
app.use(slowQueryMonitor(1000)); // 1秒慢查询阈值
app.use(memoryLeakMonitor());

// API限流中间件（仅对API路由生效）
// 开发环境使用更宽松的限制，生产环境使用严格限制
const rateLimitConfig = process.env.NODE_ENV === 'development'
  ? { windowMs: 1 * 60 * 1000, max: 500 } // 开发环境：1分钟500次
  : { windowMs: 15 * 60 * 1000, max: 1000 }; // 生产环境：15分钟1000次

app.use('/api/', rateLimiter(rateLimitConfig.windowMs, rateLimitConfig.max));

// 中间件
app.use(cors(corsOptions));
app.use(express.json({ limit: '50mb' })); // 增加请求体大小限制
app.use(express.urlencoded({ extended: true, limit: '50mb' }));

// 静态文件服务 - 提供上传的文件访问
const path = require('path');
app.use('/uploads', express.static(path.join(__dirname, '../uploads')));

// 添加请求记录中间件（仅在明确启用时记录）
const enableRequestLogs = process.env.ENABLE_REQUEST_LOGS === 'true' && process.env.NODE_ENV === 'development';
if (enableRequestLogs) {
  app.use((req, res, next) => {
    // 只记录API请求，过滤静态资源和健康检查
    if (req.url.startsWith('/api/') && !req.url.includes('/health')) {
      console.log(`🌐 ${req.method} ${req.url} - ${req.ip}`);
    }
    next();
  });
}

// 日志中间件配置
if (process.env.NODE_ENV === 'development') {
  console.log('🔧 开发环境运行中...');
  // 开发环境：只在启用详细日志时记录
  if (process.env.ENABLE_MORGAN_LOGS === 'true') {
    app.use(morgan('dev', {
      skip: (req, res) => {
        // 跳过健康检查、静态资源和成功的简单请求
        return req.url === '/health' ||
          req.url === '/favicon.ico' ||
          (res.statusCode < 400 && req.url.startsWith('/api/') && req.method === 'GET');
      }
    }));
  }
} else {
  console.log('🚀 生产环境运行中...');
  // 生产环境：只记录错误和警告
  app.use(morgan('combined', {
    skip: (req, res) => res.statusCode < 400
  }));
}

// 健康检查端点 - 使用性能监控中间件
app.get('/health', healthCheck);

// 添加API健康检查端点
app.get('/api/health', healthCheck);

// 处理favicon请求
app.get('/favicon.ico', (req, res) => {
  res.status(204).end(); // 返回空响应，状态码204表示无内容
});

// 基础路由
app.get('/', (req, res) => {
  console.log('收到根路径请求: /');
  res.json({
    message: '欢迎使用 Trove 电商平台 API',
    version: '1.0.0',
    environment: process.env.NODE_ENV,
    documentation: '/api-docs', // 假设有API文档
    healthCheck: '/health'
  });
});

// API路由
app.use('/api/products', productRoutes);
app.use('/api/users', userRoutes);
app.use('/api/cart', cartRoutes);
app.use('/api/orders', orderRoutes);
app.use('/api/payments', require('./routes/payment.routes'));
app.use('/api/categories', categoryRoutes);
app.use('/api/shops', shopRoutes);
app.use('/api/setup', setupRoutes);
app.use('/api/banners', bannerRoutes);
app.use('/api/upload', uploadRoutes);

// 管理员路由
app.use('/api/admin', require('./routes/admin.routes'));

// 未找到路由处理
app.use(notFound);

// 错误处理中间件
app.use(errorHandler);

// 启动服务器
const startServer = async () => {
  try {
    // 数据库已经通过导入db.js自动连接了

    // 启动服务器，监听所有网络接口
    app.listen(PORT, '0.0.0.0', () => {
      console.log(`✅ 服务器运行在 http://0.0.0.0:${PORT}`);
      console.log(`✅ 本地访问: http://localhost:${PORT}`);
      console.log(`✅ 局域网访问: http://<本机IP>:${PORT}`);
      console.log(`✅ Android模拟器访问: http://10.0.2.2:${PORT}`);
      console.log(`🌎 环境: ${process.env.NODE_ENV}`);

      // 显示API路由信息
      console.log('📡 API路由:');
      console.log(`  - 产品API: http://localhost:${PORT}/api/products`);
      console.log(`  - 用户API: http://localhost:${PORT}/api/users`);
      console.log(`  - 购物车API: http://localhost:${PORT}/api/cart`);
      console.log(`  - 订单API: http://localhost:${PORT}/api/orders`);
      console.log(`  - 分类API: http://localhost:${PORT}/api/categories`);
      console.log(`  - 轮播图API: http://localhost:${PORT}/api/banners`);
      console.log(`  - 文件上传API: http://localhost:${PORT}/api/upload`);
    });
  } catch (error) {
    console.error('❌ 服务器启动失败:', error.message);
    process.exit(1);
  }
};

// 处理未捕获的Promise异常
process.on('unhandledRejection', (err) => {
  console.error('❌ 未处理的Promise拒绝:', err.message);
  if (process.env.NODE_ENV === 'development') {
    console.error(err.stack);
  }
  // 在生产环境中，我们可能希望优雅地关闭服务器
  if (process.env.NODE_ENV === 'production') {
    process.exit(1);
  }
});

// 处理未捕获的异常
process.on('uncaughtException', (err) => {
  console.error('❌ 未捕获的异常:', err.message);
  if (process.env.NODE_ENV === 'development') {
    console.error(err.stack);
  }
  // 在生产环境中，我们可能希望优雅地关闭服务器
  if (process.env.NODE_ENV === 'production') {
    process.exit(1);
  }
});

startServer(); 